package nowCoder;

import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;

public class HJ54 {
    /*
    3*5+8-0*3-6+0+0
    5-3+9*6*(6-10-2)-5
    5-3+9*6-(6-10-2)-5
    9-1+0-9+4-10-(8+4+10)-1
    -1*(-1-1)
     */
    // 栈桢解法
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Stack<String> stack = new Stack<>();
        String x = in.next();
        tack(x,0,stack);stack.forEach(System.out::println);
        while (stack.size() > 1){
            String a = stack.pop();
            String pop = stack.pop();
            String b = stack.pop();
            if (!stack.empty() && "-".equals(stack.peek())){
                switch (pop){
                    case "-": pop = "+";break;
                    case "+": pop = "-";break;
                }
            }
            stack.push(math(a,pop,b));
        }
        System.out.println(stack.pop());
    }

    public static int tack(String x, int index, Stack<String> stack1) {
        int sz = 0;
        Stack<String> stk = new Stack<>();
        for (int i = index; i < x.length(); i++) {
            char c = x.charAt(i);
            // 记录数字位数
            if (c >= '0' && c <= '9') {
                sz++;
                continue;
            }
            // 判断是否需要优先处理的乘除法
            boolean f = stk.size() > 0 && ("*".equals(stk.peek()) || "/".equals(stk.peek()));
            if (sz > 0) {
                String num = x.substring(i - sz, i);
                // 判断首位是否为负数
                if (stk.size() == 1  && "-".equals(stk.peek())) {
                    num = stk.pop() + num;
//                    if (!stk.isEmpty())
//                        stk.add("+");
                }
                stk.add(num);
                sz = 0;
            }
            // 括号迭代
            if (c == '{' || c == '[' || c == '(') {
                i = tack(x,i+1, stk);
            }
            // 优先处理乘法除法
            if (f) {
                stk.add(math(stk.pop(), stk.pop(), stk.pop()));
            }
            // 右括号返回栈计算结果
            if (c == '}' || c == ']' || c == ')') {
                while (stk.size() > 1) {
                    String a = stk.pop();
                    String pop = stk.pop();
                    String b = stk.pop();
                    // 遇见前一操作为减法时需要转换当前计算方法
                    if (!stk.empty() && "-".equals(stk.peek())){
                        switch (pop){
                            case "-": pop = "+";break;
                            case "+": pop = "-";break;
                        }
                    }
                    stk.push(math(a,pop,b));
                }
                stack1.add(stk.pop());
                return i;
            }
            if (c == '{' || c == '[' || c == '(') {
                continue;
            }
            stk.add(String.valueOf(c));
        }
        if (sz > 0)
            stk.add(x.substring(x.length() - sz));
        stack1.addAll(stk);
        return 0;
    }
// 队列解法
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        LinkedList<String> stack = new LinkedList<>();
//        String x = in.next();
//        tack(x,0,stack);
//        while (stack.size() > 1){
//            String a = stack.pollFirst();
//            String f = stack.pollFirst();
//            String b = stack.pollFirst();
//            stack.addFirst(math(b,f,a));
//        }
//        System.out.println(stack.pop());
//    }
//
//    public static int tack(String x, int index, LinkedList<String> stack1) {
//        int sz = 0;
//        LinkedList<String> stk = new LinkedList<>();
//        for (int i = index; i < x.length(); i++) {
//            char c = x.charAt(i);
//            if (c >= '0' && c <= '9') {
//                sz++;
//                continue;
//            }
//            boolean f = stk.size() > 0 && ("*".equals(stk.peekLast()) || "/".equals(stk.peekLast()));
//            if (sz > 0) {
//                String num = x.substring(i - sz, i);
//                if (!stk.isEmpty() && "-".equals(stk.peek())) {
//                    num = stk.pollLast() + num;
////                    if (!stk.isEmpty())
////                        stk.add("+");
//                }
//                stk.add(num);
//                sz = 0;
//            }
//            if (c == '{' || c == '[' || c == '(') {
//                i = tack(x,i+1, stk);
//            }
//            if (f) {
//                stk.add(math(stk.pollLast(), stk.pollLast(), stk.pollLast()));
//            }
//            if (c == '}' || c == ']' || c == ')') {
//                while (stk.size() > 1) {
//                    String a = stk.pollFirst();
//                    String ff = stk.pollFirst();
//                    String b = stk.pollFirst();
//                    stk.addFirst(math(b,ff,a));
//                }
//                stack1.add(stk.pollLast());
//                return i;
//            }
//            if (c == '{' || c == '[' || c == '(') {
//                continue;
//            }
//            stk.add(String.valueOf(c));
//        }
//        if (sz > 0)
//            stk.add(x.substring(x.length() - sz));
//        stack1.addAll(stk);
//        return 0;
//    }
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        String x = in.next();
//        int ns = 0; // 数字位数
//        Stack<String> stack = new Stack<>();
//        for (int i = 0; i < x.length(); i++) {
//            char c = x.charAt(i);
//            if (c >= '0' && c <= '9') {
//                ns++;
//            } else if (c == '-') {
//                stack.push(x.substring(i - ns, i));
//                if (i != 0 && x.charAt(i - 1) <= '9' && x.charAt(i - 1) >= '0') {
//                    stack.push("+");
//                }
//                ns = 1;
//            } else {
//                boolean f = !stack.empty() && ("*".equals(stack.peek()) || "/".equals(stack.peek())) && c != '{' && c != '['&& c != '(';
//                if (ns != 0)
//                    stack.push(x.substring(i - ns, i));
//                if (f) {
//                    // 计算，压结果入栈
//                    stack.push(math(stack.pop(),stack.pop(),stack.pop()));
//                }
//                if (c == '}' || c == ']' || c == ')'){
//                    while (true){
//                        String math = math(stack.pop(), stack.pop(), stack.pop());
//                        if ("{".equals(stack.peek()) || "[".equals(stack.peek()) || "(".equals(stack.peek())){
//                            stack.pop();
//                            if (!"+".equals(stack.peek())) {
//                                stack.push(math);
//                                stack.push(math(stack.pop(), stack.pop(), stack.pop()));
//                                break;
//                            }
//                        }
//                        stack.push(math);
//                    }
//                }else
//                    // 压入计算符号
//                    stack.push(String.valueOf(c));
//                ns = 0;
//            }
//        }
//        if (ns > 0){
//            stack.push(x.substring(x.length()-ns));
//        }
//        String k = stack.pop();
//        while (!stack.empty()){
//            String fh = stack.pop();
//            String y = stack.pop();
//            if ("0".equals(y)){
//                stack.pop();
//                y = stack.pop();
//            }
//            k = math(k,fh,y);
//        }
//        System.out.println(k);
//    }

    public static String math(String x, String f, String y) {
        int xx = Integer.parseInt(x);
        int yy = Integer.parseInt(y);
        switch (f) {
            case "+" : {
                return String.valueOf(yy + xx);
            }
            case "-" : {
                return String.valueOf(yy - xx);
            }
            case "*" : {
                return String.valueOf(yy * xx);
            }
            case "/" : {
                return String.valueOf(yy / xx);
            }
        }
        return "0";
    }
}
